package cqie.frame.controller;


import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import cqie.frame.entity.*;
import cqie.frame.entity.po.*;
import cqie.frame.entity.qo.SysRoleQo;
import cqie.frame.entity.vo.SysRoleVo;
import cqie.frame.entity.vo.SysUserVo;
import cqie.frame.response.CodeMsg;
import cqie.frame.response.ResultJson;
import cqie.frame.service.*;
import io.swagger.annotations.ApiOperation;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
import org.thymeleaf.util.StringUtils;

import java.util.ArrayList;
import java.util.List;


/**
 * <p>
 * 此表为角色表，表明角色的基本信息，如角色名称，状态。 前端控制器
 * </p>
 *
 * @author HHL
 * @since 2021-09-02
 */
@RestController
@RequestMapping("/role")
public class SysRoleController {
    @Autowired
    ISysRoleService iSysRoleService;
    @Autowired
    ISysUserService iSysUserService;
    @Autowired
    ISysMenuService iSysMenuService;
    @Autowired
    IRoleMenuService iRoleMenuService;
    @Autowired
    IUserRoleService iUserRoleService;



    //选择角色
    @ApiOperation(value = "角色列表")
    @GetMapping("/roleList")
    public ResultJson roleList(){
        try {
            //选项的list
            List<SelectListItem> listItemList = new ArrayList<>();
            QueryWrapper<SysRole> queryWrapper = new QueryWrapper();
            queryWrapper.eq("status",0);
            //查询出所有角色信息
            List<SysRole> roleList = iSysRoleService.list(queryWrapper);
            //把角色信息循环取到选项的list
            roleList.forEach(x -> {
                listItemList.add(SelectListItem.SelectListItem(x.getId(),x.getName()));
            });
            return ResultJson.success(listItemList);
        }catch (Exception e){
            return ResultJson.error(CodeMsg.SERVER_ERROR);
        }
    }
    //新增角色
    @ApiOperation(value = "新增角色",notes = "新增角色，同时更新角色菜单表。",response = SysRolePo.class)
    @PostMapping(value = "/addRole")
    public ResultJson addRole(@RequestBody SysRolePo po){
        try {
            SysRole mo = new SysRole();
            //复制po的属性到sysRole,第三个参数可选，为忽略某些属性
            BeanUtils.copyProperties(po,mo);
            //插入角色表后回显插入角色的主键id
            iSysRoleService.save(mo);
            po.setId(mo.getId());
            //若一个角色有多个菜单，批量插入角色菜单表
            if(po.getMenuIdList().size()>0){
                List<RoleMenu> roleMenuList = new ArrayList<>();
                po.getMenuIdList().forEach(x->{
                    RoleMenu roleMenu = new RoleMenu();
                    //设置为选中的菜单id
                    roleMenu.setMenuId(x);
                    //设置为角色表回显的角色id
                    roleMenu.setRoleId(mo.getId());
                    roleMenuList.add(roleMenu);
                });
                //插入一个list的角色菜单表
                iRoleMenuService.saveBatch(roleMenuList);
            }
            //返回角色及其菜单id
            return ResultJson.success(po);
        }catch (Exception e){
            return ResultJson.error(CodeMsg.SERVER_ERROR);
        }
    }
    //删除角色
    @ApiOperation(value = "删除角色",notes = "删除角色，同时更新角色菜单表。")
    @GetMapping(value = "/deleteRole")
    public ResultJson deleteRole(long id){
        try {
            //删除角色需要删除用户角色表，角色菜单表，角色表。
            //1.删除角色菜单表
            //选择器，只有RoleMenu的roleId等同于要删除角色的id，才执行删除角色菜单表
            QueryWrapper<RoleMenu> qw = new QueryWrapper<>();
            qw.eq("roleId",id);
            iRoleMenuService.remove(qw);
            //2.删除用户角色表
            //选择器，只有UserRole的roleId等同于要删除角色的id，才执行删除用户角色表
            QueryWrapper<UserRole> qww = new QueryWrapper<>();
            qww.eq("roleId",id);
            iUserRoleService.remove(qww);
            //3.删除角色表
            iSysRoleService.removeById(id);
            //返回前端
            return ResultJson.success("删除成功");
        }catch (Exception e){
            return ResultJson.error(CodeMsg.SERVER_ERROR);
        }
    }

    //删除多选的角色
    @ApiOperation(value = "删除选中角色",notes = "删除角色，同时更新角色菜单表。")
    @PostMapping(value = "/deleteCheckRole")
    public ResultJson deleteCheckRole(@RequestBody Long[] roleIdList){
        try {
            //删除角色需要删除用户角色表，角色菜单表，角色表。
            //1.删除角色菜单表
            //选择器，只有RoleMenu的roleId等同于要删除角色的id，才执行删除角色菜单表
            for (int i=0;i<roleIdList.length;i++) {
                QueryWrapper<RoleMenu> qw = new QueryWrapper<>();
                qw.eq("roleId", roleIdList[i]);
                iRoleMenuService.remove(qw);
            }
            //2.删除用户角色表
            //选择器，只有UserRole的roleId等同于要删除角色的id，才执行删除用户角色表
            for (int i=0;i<roleIdList.length;i++) {
                QueryWrapper<UserRole> qww = new QueryWrapper<>();
                qww.eq("roleId", roleIdList[i]);
                iUserRoleService.remove(qww);
            }
            //3.删除角色表
            for (int i=0;i<roleIdList.length;i++) {
                iSysRoleService.removeById(roleIdList[i]);
            }
            //返回前端
            return ResultJson.success("删除成功");
        }catch (Exception e){
            return ResultJson.error(CodeMsg.SERVER_ERROR);
        }
    }
    //注销/恢复选中角色，多选
    @ApiOperation(value = "注销/恢复选中角色", notes = "注销/恢复选中角色，同时更新角色表。")
    @PostMapping(value = "/disabledCheckRole")
    public ResultJson disabledCheckRole( @RequestBody Long[] roleIdList) {
        try {
            for (int i=0;i<roleIdList.length;i++){
                SysRole sysRole = new SysRole();
                //选择器，只有UserRole的userid等同于要删除用户的id，才执行删除用户角色表
                sysRole = iSysRoleService.getById(roleIdList[i]);
                if (sysRole.getStatus()==0){
                    //如果修改前为正常，修改为禁用
                    sysRole.setStatus(1);
                } else if (sysRole.getStatus()==1) {
                    //如果修改前为禁用，修改为正常
                    sysRole.setStatus(0);
                }
                iSysRoleService.updateById(sysRole);
            }
            return ResultJson.success("修改成功");
        } catch (Exception e) {
            return ResultJson.error(CodeMsg.SERVER_ERROR);
        }
    }
    //注销/恢复角色
    @ApiOperation(value = "注销/恢复单个角色", notes = "注销/恢复单个角色，同时更新角色表。")
    @GetMapping(value = "/disabledRole")
    public ResultJson disabledRole(long id) {
        try {
            //选择器，只有SysUser的userid等同于要注销/恢复用户的id，才执行修改用户表
            SysRole sysRole = new SysRole();
            sysRole = iSysRoleService.getById(id);
            if (sysRole.getStatus()==0){
                //如果状态为正常，修改为禁用
                sysRole.setStatus(1);
            }else if (sysRole.getStatus()==1){
                //如果状态为禁用，修改为正常
                sysRole.setStatus(0);
            }
            //修改
            iSysRoleService.updateById(sysRole);
            return ResultJson.success("操作成功");
        } catch (Exception e) {
            return ResultJson.error(CodeMsg.SERVER_ERROR);
        }
    }
    //修改角色
    @ApiOperation(value = "修改角色",notes = "修改角色，同时更新角色菜单表。")
    @PostMapping(value = "/updateRole")
    public ResultJson updateRole(@RequestBody SysRolePo po){
        try {
            SysRole sysRole = new SysRole();
            //复制po的属性到sysRole,第三个参数可选，为忽略某些属性
            BeanUtils.copyProperties(po,sysRole);
            //修改角色
            iSysRoleService.updateById(sysRole);
            //选择器，先把所有角色菜单表中等同于要修改角色的角色id删除
            QueryWrapper<RoleMenu> qw = new QueryWrapper<>();
            qw.eq("roleId",po.getId());
            iRoleMenuService.remove(qw);
            //判断修改角色时选中的菜单是否为空
            if(po.getMenuIdList().size()>0){
                List<RoleMenu> roleMenuList = new ArrayList<>();
                //循环把选中的菜单，添加到角色菜单表
                po.getMenuIdList().forEach(x->{
                    RoleMenu roleMenu = new RoleMenu();
                    //roleId为修改角色的id
                    roleMenu.setRoleId(po.getId());
                    //menuId为选中的菜单id
                    roleMenu.setMenuId(x);
                    roleMenuList.add(roleMenu);
                });
                //以list的方式重新插入角色菜单表
                iRoleMenuService.saveBatch(roleMenuList);
            }
            return ResultJson.success("修改成功");
        }catch (Exception e){
            return ResultJson.error(CodeMsg.SERVER_ERROR);
        }
    }

    //角色条件分页查询
    @PostMapping(value = "/roleListPages")
    @ApiOperation(value = "角色分页查询", response = SysRole.class)
    public ResultJson roleListPages(@RequestBody SysRoleQo qo) {
        try {
            //分页参数的配置
            Page<SysRole> page = new Page<>(qo.getPageIndex(), qo.getPageSize());
            //查询条件,是否输入查询条件，如角色名称，状态等
            //是否查询用户名
            QueryWrapper<SysRole> queryWrapper = new QueryWrapper<>();
            if (!StringUtils.isEmpty(qo.getName())) {
                //不为空，启用查询
                //查询模糊查询
                queryWrapper.like("name", qo.getName());
            }
            //是否查询状态
            if (qo.getStatus() != null) {
                //不为空，启用查询
                queryWrapper.eq("status", qo.getStatus());
            }
            //根据条件以及分页查询
            IPage<SysRole> resultPage = iSysRoleService.page(page, queryWrapper);
            //映射查询结果
            //映射角色状态
            IPage<SysRoleVo> vo = new Page<>();
            List<SysRoleVo> sysRoleVoList = new ArrayList<>();
            //分页数据的复制给vo
            BeanUtils.copyProperties(resultPage, vo);
            //循环把分页数据的用户状态映射
            for (SysRole mo : resultPage.getRecords()) {
                SysRoleVo sysRoleVo = new SysRoleVo();
                BeanUtils.copyProperties(mo, sysRoleVo);
                sysRoleVo.setStatusShow(mo.getStatus() == 0 ? "正常" : "禁用");
                //分页新增一个用户信息
                sysRoleVoList.add(sysRoleVo);
            }
            //赋值给分页
            vo.setRecords(sysRoleVoList);
            return ResultJson.success(vo);
        } catch (Exception e) {
            return ResultJson.error(CodeMsg.SERVER_ERROR);
        }
    }
    //根据角色ID进入角色的详细页面
    @ApiOperation(value = "角色详情")
    @GetMapping(value = "/selectRoleById")
    public ResultJson selectRoleById(long id){
        try {
            //需要查询角色信息，角色对应菜单信息，角色对应用户信息
            //角色po类
            RoleUserMenuPo roleUserMenuPo = new RoleUserMenuPo();
            //1.角色信息
            //先根据角色id查到角色
            SysRole sysRole = iSysRoleService.getById(id);
            //复制sysRole的属性到roleUserMenuPo,第三个参数可选，为忽略某些属性
            BeanUtils.copyProperties(sysRole, roleUserMenuPo);
            //2.角色对应用户信息，根据角色id查询用户角色中间表
            QueryWrapper<UserRole> queryWrapper = new QueryWrapper();
            queryWrapper.eq("roleId", id);
            List<UserRole> userRoleList = iUserRoleService.list(queryWrapper);
            //用户信息
            List<SysUser> sysUserList = new ArrayList<>();
            //根据用户角色表查询出用户表
            userRoleList.forEach(x -> {
                SysUser sysUser = new SysUser();
                //根据用户角色表的角色id查询出角色信息
                sysUser = iSysUserService.getById(x.getUserId());
                sysUserList.add(sysUser);
            });
            //把用户List插入到角色po类
            roleUserMenuPo.setUserList(sysUserList);
            //3.角色对应菜单信息，根据角色id查询角色菜单中间表
            QueryWrapper<RoleMenu> queryWrapper1 = new QueryWrapper();
            queryWrapper1.eq("roleId", id);
            List<RoleMenu> roleMenuList = iRoleMenuService.list(queryWrapper1);
            //菜单信息
            List<SysMenu> sysMenuList = new ArrayList<>();
            //循环根据角色菜单表查询出菜单
            roleMenuList.forEach(x ->{
                SysMenu sysMenu = new SysMenu();
                sysMenu = iSysMenuService.getById(x.getMenuId());
                sysMenuList.add(sysMenu);
            });
            //把菜单List插入到角色Po类
            roleUserMenuPo.setMenuList(sysMenuList);

            return ResultJson.success(roleUserMenuPo);
        }catch (Exception e){
            return ResultJson.error(CodeMsg.SERVER_ERROR);
        }
    }
}

